
/*

https://www.acwing.com/problem/content/289/

有一个树形的水系，由 N−1条河道和 N个交叉点组成。

我们可以把交叉点看作树中的节点，编号为 1∼N，河道则看作树中的无向边。

每条河道都有一个容量，连接 x与 y的河道的容量记为 c(x,y)。

河道中单位时间流过的水量不能超过河道的容量。

有一个节点是整个水系的发源地，可以源源不断地流出水，我们称之为源点。

除了源点之外，树中所有度数为 1
 的节点都是入海口，可以吸收无限多的水，我们称之为汇点。

也就是说，水系中的水从源点出发，沿着每条河道，最终流向各个汇点。

在整个水系稳定时，每条河道中的水都以单位时间固定的水量流向固定的方向。

除源点和汇点之外，其余各点不贮存水，也就是流入该点的河道水量之和等于从该点流出的河道水量之和。

整个水系的流量就定义为源点单位时间发出的水量。

在流量不超过河道容量的前提下，求哪个点作为源点时，整个水系的流量最大，输出这个最大值。

输入格式
输入第一行包含整数 T，表示共有 T组测试数据。

每组测试数据，第一行包含整数 N。

接下来 N−1行，每行包含三个整数 x,y,z
，表示 x，y 之间存在河道，且河道容量为 z。

节点编号从 1开始。

输出格式
每组数据输出一个结果，每个结果占一行。

数据保证结果不超过 231−1
。

数据范围
N≤2×105
输入样例：
1
5
1 2 11
1 4 13
3 4 5
4 5 10
输出样例：
26
*/

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 200010, M = N * 2, INF = 0x3f3f3f3f;

int n;
int h[N], e[M], w[M], ne[M], idx;
int d[N], f[N], deg[N];

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

int dfs_d(int u, int fa)
{
	//到底 返回inf
    if (deg[u] == 1)
    {
        d[u] = INF;
        return d[u];
    }

	//
    d[u] = 0;
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (j == fa) continue;
        d[u] += min(w[i], dfs_d(j, u));
    }

    return d[u];
}

void dfs_f(int u, int fa)
{
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (j == fa) continue;
        if (deg[j] == 1) f[j] = min(w[i], f[u] - w[i]);
        else
        {
            f[j] = d[j] + min(f[u] - min(d[j], w[i]), w[i]);
            dfs_f(j, u);
        }
    }
}

int main()
{
    int T;
    scanf("%d", &T);
    while (T -- )
    {
        scanf("%d", &n);
        memset(h, -1, sizeof h);
        idx = 0;
        memset(deg, 0, sizeof deg);

        for (int i = 0; i < n - 1; i ++ )
        {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            add(a, b, c), add(b, a, c);
            deg[a] ++ , deg[b] ++ ;
        }

        int root = 1;
        while (root <= n && deg[root] == 1) root ++ ;
		
        if (root > n)
        {
            cout << w[0] << endl;
            continue;
        }

        dfs_d(root, -1);
        f[root] = d[root];
        dfs_f(root, -1);

        int res = 0;
        for (int i = 1; i <= n; i ++ ) res = max(res, f[i]);

        printf("%d\n", res);
    }

    return 0;
}

 